<html>
<head><meta charset="utf-8"><title>Procedural macro on expressions · general · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/index.html">general</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html">Procedural macro on expressions</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="226323313"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226323313" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226323313">(Feb 14 2021 at 20:31)</a>:</h4>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/182449-t-compiler.2Fhelp/topic/procedural.20macro.20on.20expression/near/226297536">said</a>:</p>
<blockquote>
<p>Any idea/RFC for procedural macro on expressions? For example:</p>
<p><div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">fn</span> <span class="nf">example</span><span class="p">(</span><span class="n">v</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">  </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
<span class="w">  </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">counter</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
<span class="w">  </span><span class="cp">#[invariant(...)]</span><span class="w"></span>
<span class="w">  </span><span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"></span>
<span class="w">    </span><span class="n">counter</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">i</span><span class="p">;</span><span class="w"></span>
<span class="w">  </span><span class="p">}</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div><br>
</p>
</blockquote>



<a name="226323370"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226323370" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226323370">(Feb 14 2021 at 20:32)</a>:</h4>
<p>yes: <a href="https://blog.rust-lang.org/2020/07/16/Rust-1.45.0.html#stabilizing-function-like-procedural-macros-in-expressions-patterns-and-statements">https://blog.rust-lang.org/2020/07/16/Rust-1.45.0.html#stabilizing-function-like-procedural-macros-in-expressions-patterns-and-statements</a></p>



<a name="226323404"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226323404" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226323404">(Feb 14 2021 at 20:33)</a>:</h4>
<p>in short <span aria-label="laughing" class="emoji emoji-1f606" role="img" title="laughing">:laughing:</span></p>



<a name="226323910"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226323910" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226323910">(Feb 14 2021 at 20:46)</a>:</h4>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226323370">said</a>:</p>
<blockquote>
<p>yes: <a href="https://blog.rust-lang.org/2020/07/16/Rust-1.45.0.html#stabilizing-function-like-procedural-macros-in-expressions-patterns-and-statements">https://blog.rust-lang.org/2020/07/16/Rust-1.45.0.html#stabilizing-function-like-procedural-macros-in-expressions-patterns-and-statements</a></p>
</blockquote>
<p>Thanks. But does this apply to attribute marcos? For example:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#[proc_macro_attribute]</span><span class="w"></span>
<span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">invariant</span><span class="p">(</span><span class="n">_attr</span>: <span class="nc">TokenStream</span><span class="p">,</span><span class="w"> </span><span class="n">item</span>: <span class="nc">TokenStream</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nc">TokenStream</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">item</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="226324235"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226324235" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226324235">(Feb 14 2021 at 20:53)</a>:</h4>
<p>like this: <a href="https://github.com/rust-lang/rust/pull/80689">https://github.com/rust-lang/rust/pull/80689</a>?</p>



<a name="226326253"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226326253" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226326253">(Feb 14 2021 at 21:41)</a>:</h4>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226324235">said</a>:</p>
<blockquote>
<p>like this: <a href="https://github.com/rust-lang/rust/pull/80689">https://github.com/rust-lang/rust/pull/80689</a>?</p>
</blockquote>
<p>I think this works to an extend, essential what I am looking for is for a attribute/macro to capture the next block. Eg: </p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#[some_attr]</span><span class="w"></span>
<span class="k">while</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="mi">5</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">do_stuff</span><span class="p">();</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">;</span><span class="w"> </span><span class="p">}</span><span class="w"></span>

<span class="cp">#[proc_macro_attribute]</span><span class="w"></span>
<span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">some_attr</span><span class="p">(</span><span class="n">args</span>: <span class="nc">TokenStream</span><span class="p">,</span><span class="w"> </span><span class="n">input</span>: <span class="nc">TokenStream</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nc">TokenStream</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="c1">// input == TokenStream of the while block</span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>
<p>But I suppose it is deduceable with some for information for example span of the attribute usage?</p>



<a name="226326660"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226326660" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226326660">(Feb 14 2021 at 21:51)</a>:</h4>
<p>I've never seen anything like that before</p>



<a name="226326821"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226326821" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226326821">(Feb 14 2021 at 21:55)</a>:</h4>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326660">said</a>:</p>
<blockquote>
<p>I've never seen anything like that before</p>
</blockquote>
<p>Would you think that is something makes sense/possible? My use case here is to "annotate" a block of code and process them</p>



<a name="226326882"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226326882" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Aaron Hill <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226326882">(Feb 14 2021 at 21:56)</a>:</h4>
<p>See <a href="https://github.com/rust-lang/rust/issues/15701">https://github.com/rust-lang/rust/issues/15701</a></p>



<a name="226326908"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226326908" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226326908">(Feb 14 2021 at 21:57)</a>:</h4>
<p>i know it's been suggested beore for stuff like</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#[likely]</span><span class="w"></span>
<span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">blah</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>



<a name="226327177"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226327177" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226327177">(Feb 14 2021 at 22:00)</a>:</h4>
<p>and stuff like #[allow(...)] works this way i believe</p>



<a name="226327349"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226327349" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226327349">(Feb 14 2021 at 22:01)</a>:</h4>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326821">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326660">said</a>:</p>
<blockquote>
<p>I've never seen anything like that before</p>
</blockquote>
<p>Would you think that is something makes sense/possible? My use case here is to "annotate" a block of code and process them</p>
</blockquote>
<p>it's not a very explicit approach is it?</p>



<a name="226328491"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226328491" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226328491">(Feb 14 2021 at 22:09)</a>:</h4>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226327349">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326821">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326660">said</a>:</p>
<blockquote>
<p>I've never seen anything like that before</p>
</blockquote>
<p>Would you think that is something makes sense/possible? My use case here is to "annotate" a block of code and process them</p>
</blockquote>
<p>it's not a very explicit approach is it?</p>
</blockquote>
<p>What do you mean by that?</p>



<a name="226328681"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226328681" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226328681">(Feb 14 2021 at 22:12)</a>:</h4>
<p><span class="user-mention silent" data-user-id="125294">Aaron Hill</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326882">said</a>:</p>
<blockquote>
<p>See <a href="https://github.com/rust-lang/rust/issues/15701">https://github.com/rust-lang/rust/issues/15701</a></p>
</blockquote>
<p>Thanks, I think that is the issue I am looking for.</p>



<a name="226342723"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226342723" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oliver <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226342723">(Feb 15 2021 at 03:48)</a>:</h4>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226328491">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226327349">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326821">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326660">said</a>:</p>
<blockquote>
<p>I've never seen anything like that before</p>
</blockquote>
<p>Would you think that is something makes sense/possible? My use case here is to "annotate" a block of code and process them</p>
</blockquote>
<p>it's not a very explicit approach is it?</p>
</blockquote>
<p>What do you mean by that?</p>
</blockquote>
<p>I think in terms of the compiler locality of reasoning refers to being explicit as<br>
being able to reason about code without having to reference other locations</p>



<a name="226347012"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226347012" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> kentrixy <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226347012">(Feb 15 2021 at 05:35)</a>:</h4>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226342723">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226328491">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226327349">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="389506">kentrixy</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326821">said</a>:</p>
<blockquote>
<p><span class="user-mention silent" data-user-id="281739">oliver</span> <a href="#narrow/stream/122651-general/topic/Procedural.20macro.20on.20expressions/near/226326660">said</a>:</p>
<blockquote>
<p>I've never seen anything like that before</p>
</blockquote>
<p>Would you think that is something makes sense/possible? My use case here is to "annotate" a block of code and process them</p>
</blockquote>
<p>it's not a very explicit approach is it?</p>
</blockquote>
<p>What do you mean by that?</p>
</blockquote>
<p>I think in terms of the compiler locality of reasoning refers to being explicit as<br>
being able to reason about code without having to reference other locations</p>
</blockquote>
<p>Sorry if I misunderstood, but isn't an attribute directly on a statement/expression block explicit enough for the compiler?</p>



<a name="226354834"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226354834" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Laurențiu <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226354834">(Feb 15 2021 at 08:13)</a>:</h4>
<p>To me, it seems it mostly is. However, consider <code>#[likely] if x == f(y, a == b)</code>; what does the attribute apply to? Sure, it's the outer expression. But you might also want to add one to the inner <code>a == b</code> comparison, like in <code>f(y, #[likely a == b)</code>.</p>



<a name="226354858"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226354858" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Laurențiu <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226354858">(Feb 15 2021 at 08:13)</a>:</h4>
<p>Other than this, proc macro attributes on statements make sense to me.</p>



<a name="226355092"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226355092" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Laurențiu <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226355092">(Feb 15 2021 at 08:16)</a>:</h4>
<p>For pattern matching, <code>if let #[likely] Some(x) = f()</code> would be more clear to the compiler (and could work for <code>match</code>, too)</p>



<a name="226381390"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/122651-general/topic/Procedural%20macro%20on%20expressions/near/226381390" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Daniel Henry-Mantilla <a href="https://rust-lang.github.io/zulip_archive/stream/122651-general/topic/Procedural.20macro.20on.20expressions.html#226381390">(Feb 15 2021 at 13:06)</a>:</h4>
<p>FWIW, this is possible in today Rust using the pre-processor pattern, as showcased by <a href="https://docs.rs/with_locals">https://docs.rs/with_locals</a> tracking call-sites <code>#[with] let x = foo();</code> :</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#[with]</span><span class="w"> </span><span class="c1">// --(preprocessor)-+ sees</span>
<span class="k">fn</span> <span class="nf">wrapping_function</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">// |</span>
<span class="w">    </span><span class="o">..</span><span class="p">.</span><span class="w"> </span><span class="c1">//                  |</span>
<span class="w">    </span><span class="cp">#[with]</span><span class="w"> </span><span class="c1">// &lt;--(marker)--+</span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">foo</span><span class="p">();</span><span class="w"></span>
<span class="w">    </span><span class="o">..</span><span class="p">.</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>